
[Description de la premère méthode de gestion des paragraphes]
	
	* Simple utilisation du composant html de Java pour l'ensemble de la page.

	+ Simple à mettre en oeuvre.

	- Très lent à afficher et redimensionner. Et la page html complète doit encore grossir.
	- Pas si évident de savoir sur quel paragraphe on fait un clic droit pour réagir à cette action.
	- Le découpage des paragraphes constituant la page html est de toutes manières nécessaire pour remplir
	  la liste de régions et de paragraphes.


[Description de la deuxième méthode de gestion des paragraphes]

	* Création d'un panneau pour chaque paragraphe.
	* Affichage d'une dizaine de panneaux (en principe ce nombre devrait être ajusté pour tenir compte de
	  la taille des panneaux affichés à un moment donné et de la taille de la zone visible dans le
	  navigateur).
	* Ascenseur vertical géré à la main, qui affiche/masque les paragraphes concernés.

	+ Rapide : il n'y a qu'une dizaine de paragraphes à réafficher (donc à recalculer) quand on redimensionne
	  le panneau.
	+ Facile de se positionner sur un paragraphe (afficher ce paragraphe et les 9 suivants, masquer les
	  autres).
	+ Facile de déterminer le paragraphe sur lequel on a cliqué.

	- Difficile de gérer le défilement proprement : défiler d'un paragraphe à l'autre est simple, mais
	  défiler plus lentement et plus régulièrement ou encore sauter plus loin avec l'ascenseur est très
	  compliqué, notamment du fait qu'on ne connaît pas la taille totale des navigateurs et qu'il faut faire
	  des bidouilles pour décaler les paragraphes d'une ligne (des idées à base de panneau masqué au-dessus de
	  tous les autres, qui grandirait/rétrécirait pour décaler les paragraphes affichés en dessous, le tout
	  combiné avec une fenêtre défilante (mais sans barre de défilement) pour n'afficher que ce qu'il faut
	  [à moins que la fenêtre de défilement seule n'ait suffi finalement]). La molette de la souris doit être
	  gérée à la main.

	
[Description de la nouvelle méthode de gestion des paragraphes]

	* Les paragraphes sont découpés et placés dans des panneaux, comme dans la solution précédente.
	* Tous les paragraphes sont affichés en même temps, il n'y a pas d'affichage/masquage des paragraphes.
	* Une fenêtre défilante permet de gérer le défilement simplement.
	* Avant le premier affichage, les paragraphes sont créés de manière asynchrone (enfin ça implique quand
	  même le fil d'exécution de Swing mais par petits morceaux, ce qui permet d'afficher l'interface
	  rapidement (sans attendre le chargement des paragraphes) et sans bloquer le reste de l'interface).
	
	+ Plus simple que la solution précédente, le défilement est géré correctement et simplement.
	+ La fenêtre s'affiche rapidement, avant que les paragraphes soient chargés.
	
	- Redimensionnement moins rapide que la solution précédente avec affichage/masquage des paragraphes.
	- Nécessite de gérer le chargement différé des paragraphes à plusieurs endroits : le chargement lui-même,
	  mais aussi le fait que les paragraphes ne sont pas prêts pour les actions lors de l'affichage de la
	  fenêtre.

	* Notes sur les essais (réussis ou échoués) de gestion asynchrone des paragraphes du navigateur.
		! Toutes ces notes concernent le composant HTML de la JVM, je n'ai pas tout repris avec le composant
		  de Cobra.
		! Test d'appel de méthode avec invokeLater (une méthode qui s'appelle elle-même sans rien faire
		  d'autre) : cet appel est assez rapide (nettement plus lent qu'appeler la méthode directement, mais
		  pas très violent (sur un Athlon 1800+ : 250 appels en 280 ms)).
		x Utiliser invokeLater pour ajouter les paragraphes de manière "asynchrone" au navigateur ralentit
		  considérablement l'opération (quelque chose comme 10 fois plus lent, même si c'est un peu compensé
		  pour l'utilisateur par le fait que ça ne bloque pas l'interface et qu'on peut faire un truc plus ou
		  moins compliqué pour afficher en premier les paragraphes qui nous intéressent (ceux qui sont
		  visibles à ce moment)).
		    => Laissé tomber.
		- Utiliser invokeLater pour créer les paragraphes de manière "asynchrone" ralentit un peu le
		  traitement mais pas énormément (d'ailleurs ça peut aussi être en partie à cause de la carte qui est
		  en train de se tracer pendant un moment), et l'interface est disponible pendant ce temps.
		    => Ok, ça marche.
		x Afficher les paragraphes au fur et à mesure qu'ils sont créés ralentit considérablement l'opération.
		    => Laissé tomber. Un message est affiché dans le navigateur en attendant que les paragraphes
		       soient prêts à être affichés.
		x Charger les navigateurs (composant graphiques des paragraphes) dans un autre fil d'exécution
			! C'est l'affichage des paragraphes qui prend du temps. Notamment quand on les redimensionne et
			  qu'il faut recalculer leur disposition (l'organisation du texte dans le composant).
			x Essai d'affichage des composants hors-écran (appeler leur méthode paintComponent avec un
			  pinceau sur un panneau bidon, pour les forcer à calculer leur disposition dans le fil
			  d'exécution séparé et que l'affichage réel soit rapide (le deuxième affichage est nettement
			  plus rapide si la taille du composant n'a pas varié)).
			    => Echec : apparemment on se retrouve quand même à éxécuter du code dans le fil d'exécution
			       de Swing, pour une raison obscure (il semble que les appels à getPreferredSize(), qui
			       obligent le composant à déterminer sa disposition interne, figent l'interface), ce qui
			       enlève l'intérêt d'un fil d'exécution séparé. Des exceptions levées également à cause
			       d'interactions entre ces calculs d'organisation et de taille du composant et d'autres
			       événements dans le fil de Swing (j'ai aussi essayé de travailler sur des copies des
			       composants pour leur demander de s'organiser dans le second fil pendant que les originaux
			       étaient affichés, mais je n'ai rien réussi malgré de nombreuses tentatives).
			    => A priori Swing est fait pour fonctionner avec des opérations sur les composants graphiques
			       exécutés dans le fil de Swing.
